src/media_playlist.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_filter.h>
  19 #include <media_info.h>
  20 #include <media_info_private.h>
  21 #include <media_util_private.h>
  22
  23 static void __media_playlist_item_free(gpointer item)
  24 {
  25         media_playlist_item_s *_item = (media_playlist_item_s *)item;
  26
  27         g_free(_item->media_id);
  28         g_free(_item->playlist_name);
  29         g_free(_item->thumbnail_path);
  30         g_free(_item);
  31 }
  32
  33 static void __media_playlist_item_release(media_playlist_s *playlist)
  34 {
  35         if (!playlist || !playlist->item_list)
  36                 return;
  37
  38         g_list_free_full(playlist->item_list, __media_playlist_item_free);
  39         playlist->item_list = NULL;
  40 }
  41
  42 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
  43 {
  44         int ret = MEDIA_CONTENT_ERROR_NONE;
  45         char *query = NULL;
  46         sqlite3_stmt *stmt = NULL;
  47
  48         query = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
  49
  50         ret = _content_query_sql(query);
  51         SQLITE3_SAFE_FREE(query);
  52         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  53
  54         query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
  55
  56         ret = _content_get_result(query, &stmt);
  57         SQLITE3_SAFE_FREE(query);
  58         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  59
  60         if (sqlite3_step(stmt) == SQLITE_ROW)
  61                 *playlist_id = sqlite3_column_int(stmt, 0);
  62
  63         SQLITE3_FINALIZE(stmt);
  64
  65         return MEDIA_CONTENT_ERROR_NONE;
  66 }
  67
  68 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
  69 {
  70         int ret = MEDIA_CONTENT_ERROR_NONE;
  71         sqlite3_stmt *stmt = NULL;
  72         char *query = NULL;
  73         int play_order = 0;
  74
  75         query = sqlite3_mprintf(SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
  76
  77         /* get the max play_order */
  78         ret = _content_get_result(query, &stmt);
  79         SQLITE3_SAFE_FREE(query);
  80         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  81
  82         if (sqlite3_step(stmt) == SQLITE_ROW)
  83                 play_order = sqlite3_column_int(stmt, 0);
  84
  85         SQLITE3_FINALIZE(stmt);
  86
  87         query = sqlite3_mprintf(INSERT_PLAYLIST_ITEM_TO_PLAYLIST_MAP, playlist_id, media_id, ++play_order);
  88         ret = media_svc_append_query(query, _content_get_uid());
  89
  90         return _content_error_capi(ret);
  91 }
  92
  93 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
  94 {
  95         int ret = MEDIA_CONTENT_ERROR_NONE;
  96         char *query_str = NULL;
  97
  98         query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
  99         ret = media_svc_append_query(query_str, _content_get_uid());
 100
 101         return _content_error_capi(ret);
 102 }
 103
 104 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
 105 {
 106         int ret = MEDIA_CONTENT_ERROR_NONE;
 107         char *query_str = NULL;
 108
 109         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
 110         ret = media_svc_append_query(query_str, _content_get_uid());
 111
 112         return _content_error_capi(ret);
 113 }
 114
 115 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
 116 {
 117         int ret = MEDIA_CONTENT_ERROR_NONE;
 118         char *query_str = NULL;
 119
 120         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
 121         ret = media_svc_append_query(query_str, _content_get_uid());
 122
 123         return _content_error_capi(ret);
 124 }
 125
 126 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
 127 {
 128         int ret = MEDIA_CONTENT_ERROR_NONE;
 129         char *query_str = NULL;
 130
 131         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
 132         ret = media_svc_append_query(query_str, _content_get_uid());
 133
 134         return _content_error_capi(ret);
 135 }
 136
 137 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
 138 {
 139         int ret = MEDIA_CONTENT_ERROR_NONE;
 140         GList **list = (GList**)user_data;
 141         char *path = NULL;
 142
 143         ret = media_info_get_file_path(media, &path);
 144         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail");
 145
 146         *list = g_list_append(*list, path);
 147
 148         return TRUE;
 149 }
 150
 151 static int __media_playlist_reset_file(const char *playlist_path)
 152 {
 153         FILE *fp = NULL;
 154
 155         fp = fopen(playlist_path, "wb");
 156         if (fp == NULL) {
 157                 content_stderror("fopen failed");
 158                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 159         }
 160
 161         fputs("", fp);  /* remove previous playlist */
 162
 163         fclose(fp);
 164
 165         return MEDIA_CONTENT_ERROR_NONE;
 166 }
 167
 168 static int __media_playlist_append_to_file(const char *playlist_path, const char *path)
 169 {
 170         FILE *fp = NULL;
 171
 172         fp = fopen(playlist_path, "a"); /* append only */
 173         if (fp == NULL) {
 174                 content_stderror("fopen failed");
 175                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 176         }
 177
 178
 179         fputs(path, fp);
 180         fputs("\n", fp);
 181
 182         fclose(fp);
 183
 184         return MEDIA_CONTENT_ERROR_NONE;
 185 }
 186
 187 static int __media_playlist_import_item_from_file(const char *playlist_path, GSList **item_list)
 188 {
 189         int tmp_str_len = 0;
 190         char tmp_str[MAX_PATH_LEN] = {0, };
 191         char repl_item[MAX_PATH_LEN] = {0, };
 192         FILE *fp = NULL;
 193
 194         fp = fopen(playlist_path, "rb");
 195         if (fp == NULL) {
 196                 content_stderror("fopen failed");
 197                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 198         }
 199
 200         while (fgets(tmp_str, MAX_PATH_LEN, fp) != NULL) {
 201                 memset(repl_item, 0, sizeof(repl_item));
 202                 _media_content_replace_path(tmp_str, repl_item);
 203
 204                 tmp_str_len = strlen(repl_item);
 205                 /* Check for empty file */
 206                 if (tmp_str_len <= 1)
 207                         continue;
 208
 209                 if (repl_item[0] == '#')
 210                         continue;
 211
 212
 213                 if (repl_item[tmp_str_len - 1] == '\n')
 214                         repl_item[tmp_str_len - 1] = '\0';
 215
 216                 *item_list = g_slist_append(*item_list, g_strdup(repl_item));
 217         }
 218
 219         fclose(fp);
 220
 221         return MEDIA_CONTENT_ERROR_NONE;
 222 }
 223
 224 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
 225 {
 226         int ret = MEDIA_CONTENT_ERROR_NONE;
 227         int playlist_id = 0;
 228
 229         content_retip_if_fail(STRING_VALID(name));
 230         content_retip_if_fail(playlist);
 231
 232         media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
 233
 234         ret = __media_playlist_insert_playlist_record(name, &playlist_id);
 235         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 236                 g_free(_playlist);
 237                 return ret;
 238         }
 239
 240         _playlist->playlist_id = playlist_id;
 241         _playlist->name = g_strdup(name);
 242
 243         *playlist = (media_playlist_h)_playlist;
 244
 245         return ret;
 246 }
 247
 248 int media_playlist_delete_from_db(int playlist_id)
 249 {
 250         int ret = MEDIA_CONTENT_ERROR_NONE;
 251         char *query_str = NULL;
 252
 253         content_retipm_if_fail(playlist_id >= 0, "%d", playlist_id);
 254
 255         query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
 256
 257         ret = _content_query_sql(query_str);
 258         SQLITE3_SAFE_FREE(query_str);
 259
 260         return ret;
 261 }
 262
 263 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
 264 {
 265         content_retip_if_fail(playlist_count);
 266
 267         return _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
 268 }
 269
 270 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
 271 {
 272         content_retip_if_fail(callback);
 273
 274         return _media_db_get_playlist(filter, callback, user_data);
 275 }
 276
 277 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
 278 {
 279         content_retip_if_fail(media_count);
 280         content_retipm_if_fail(playlist_id > 0, "%d", playlist_id);
 281
 282         return _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
 283 }
 284
 285 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 286 {
 287         content_retip_if_fail(callback);
 288         content_retipm_if_fail(playlist_id > 0, "%d", playlist_id);
 289
 290         return _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
 291 }
 292
 293 int media_playlist_destroy(media_playlist_h playlist)
 294 {
 295         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 296
 297         content_retip_if_fail(playlist);
 298
 299         __media_playlist_item_release(_playlist);
 300
 301         g_free(_playlist->name);
 302         g_free(_playlist->thumbnail_path);
 303         g_free(_playlist);
 304
 305         return MEDIA_CONTENT_ERROR_NONE;
 306 }
 307
 308 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
 309 {
 310         media_playlist_s *_src = (media_playlist_s *)src;
 311
 312         content_retip_if_fail(dst);
 313         content_retip_if_fail(src);
 314
 315         media_playlist_s *_dst = g_new0(media_playlist_s, 1);
 316
 317         _dst->playlist_id = _src->playlist_id;
 318         _dst->name = g_strdup(_src->name);
 319
 320         *dst = (media_playlist_h)_dst;
 321
 322         return MEDIA_CONTENT_ERROR_NONE;
 323 }
 324
 325 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
 326 {
 327         int ret = MEDIA_CONTENT_ERROR_NONE;
 328         sqlite3_stmt *stmt = NULL;
 329         char *query = NULL;
 330
 331         content_retipm_if_fail(playlist_id > 0, "%d", playlist_id);
 332         content_retip_if_fail(playlist);
 333
 334         query = sqlite3_mprintf(SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
 335
 336         ret = _content_get_result(query, &stmt);
 337         SQLITE3_SAFE_FREE(query);
 338         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 339
 340         media_playlist_s *_playlist = NULL;
 341
 342         if (sqlite3_step(stmt) == SQLITE_ROW) {
 343                 _playlist = g_new0(media_playlist_s, 1);
 344
 345                 _playlist->playlist_id = playlist_id;
 346                 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 347                 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 348
 349                 *playlist = (media_playlist_h)_playlist;
 350         } else {
 351                 content_error("Nonexistent playlist id[%d]", playlist_id);
 352                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 353         }
 354
 355         SQLITE3_FINALIZE(stmt);
 356
 357         return ret;
 358 }
 359
 360 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
 361 {
 362         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 363
 364         content_retip_if_fail(playlist);
 365         content_retip_if_fail(playlist_id);
 366
 367         *playlist_id = _playlist->playlist_id;
 368
 369         return MEDIA_CONTENT_ERROR_NONE;
 370 }
 371
 372 int media_playlist_get_name(media_playlist_h playlist, char **name)
 373 {
 374         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 375
 376         content_retip_if_fail(playlist);
 377         content_retip_if_fail(name);
 378
 379         *name = g_strdup(_playlist->name);
 380
 381         return MEDIA_CONTENT_ERROR_NONE;
 382 }
 383
 384 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
 385 {
 386         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 387
 388         content_retip_if_fail(playlist);
 389         content_retip_if_fail(path);
 390
 391         *path = g_strdup(_playlist->thumbnail_path);
 392
 393         return MEDIA_CONTENT_ERROR_NONE;
 394 }
 395
 396 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
 397 {
 398         int ret = MEDIA_CONTENT_ERROR_NONE;
 399         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 400         sqlite3_stmt *stmt = NULL;
 401         char *query = NULL;
 402
 403         content_retip_if_fail(playlist);
 404         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 405         content_retip_if_fail(play_order);
 406
 407         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, _playlist->playlist_id, playlist_member_id);
 408         ret = _content_get_result(query, &stmt);
 409         SQLITE3_SAFE_FREE(query);
 410         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 411
 412         if (sqlite3_step(stmt) == SQLITE_ROW)
 413                 *play_order = sqlite3_column_int(stmt, 0);
 414
 415         SQLITE3_FINALIZE(stmt);
 416
 417         return ret;
 418 }
 419
 420 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
 421 {
 422         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 423         media_playlist_item_s *item = NULL;
 424
 425         content_retip_if_fail(playlist);
 426         content_retip_if_fail(STRING_VALID(playlist_name));
 427
 428         g_free(_playlist->name);
 429
 430         item = g_new0(media_playlist_item_s, 1);
 431
 432         item->playlist_name = g_strdup(playlist_name);
 433         item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 434
 435         _playlist->name = g_strdup(playlist_name);
 436         _playlist->item_list = g_list_append(_playlist->item_list, item);
 437
 438         return MEDIA_CONTENT_ERROR_NONE;
 439 }
 440
 441 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 442 {
 443         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 444         media_playlist_item_s *item = NULL;
 445
 446         content_retip_if_fail(playlist);
 447         content_retip_if_fail(STRING_VALID(path));
 448
 449         g_free(_playlist->thumbnail_path);
 450
 451         item = g_new0(media_playlist_item_s, 1);
 452
 453         item->thumbnail_path = g_strdup(path);
 454         item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 455
 456         _playlist->thumbnail_path = g_strdup(path);
 457         _playlist->item_list = g_list_append(_playlist->item_list, item);
 458
 459         return MEDIA_CONTENT_ERROR_NONE;
 460 }
 461
 462 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 463 {
 464         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 465         media_playlist_item_s *item = NULL;
 466
 467         content_retip_if_fail(playlist);
 468         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 469         content_retipm_if_fail(play_order >= 0, "%d", play_order);
 470
 471         item = g_new0(media_playlist_item_s, 1);
 472
 473         item->playlist_member_id = playlist_member_id;
 474         item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
 475         item->play_order = play_order;
 476
 477         _playlist->item_list = g_list_append(_playlist->item_list, item);
 478
 479         return MEDIA_CONTENT_ERROR_NONE;
 480 }
 481
 482 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
 483 {
 484         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 485         media_playlist_item_s *item = NULL;
 486
 487         content_retip_if_fail(playlist);
 488         content_retip_if_fail(STRING_VALID(media_id));
 489
 490         item = g_new0(media_playlist_item_s, 1);
 491
 492         item->media_id = g_strdup(media_id);
 493         item->function = MEDIA_PLAYLIST_ADD;
 494
 495         _playlist->item_list = g_list_append(_playlist->item_list, item);
 496
 497         return MEDIA_CONTENT_ERROR_NONE;
 498 }
 499
 500 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 501 {
 502         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 503         media_playlist_item_s *item = NULL;
 504
 505         content_retip_if_fail(playlist);
 506         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 507
 508         item = g_new0(media_playlist_item_s, 1);
 509
 510         item->playlist_member_id = playlist_member_id;
 511         item->function = MEDIA_PLAYLIST_REMOVE;
 512
 513         _playlist->item_list = g_list_append(_playlist->item_list, item);
 514
 515         return MEDIA_CONTENT_ERROR_NONE;
 516 }
 517
 518 void __media_playlist_foreach_request(gpointer data, gpointer user_data)
 519 {
 520         int ret = MEDIA_CONTENT_ERROR_NONE;
 521         media_playlist_item_s *_playlist_item = (media_playlist_item_s *)data;
 522         int playlist_id = *((int *)user_data);
 523
 524         if (!_playlist_item)
 525                 return;
 526
 527         switch (_playlist_item->function) {
 528         case MEDIA_PLAYLIST_ADD:
 529                 ret = __media_playlist_insert_item_to_playlist(playlist_id, _playlist_item->media_id);
 530                 break;
 531
 532         case MEDIA_PLAYLIST_REMOVE:
 533                 ret = __media_playlist_remove_item_from_playlist(playlist_id, _playlist_item->playlist_member_id);
 534                 break;
 535
 536         case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 537                 ret = __media_playlist_update_playlist_name(playlist_id, _playlist_item->playlist_name);
 538                 break;
 539
 540         case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 541                 ret = __media_playlist_update_thumbnail_path(playlist_id, _playlist_item->thumbnail_path);
 542                 break;
 543
 544         case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 545                 ret = __media_playlist_update_play_order(playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 546                 break;
 547
 548         default:
 549                 break;
 550         }
 551
 552         if (ret != MEDIA_CONTENT_ERROR_NONE)
 553                 content_error("Failed some operation[%d]", _playlist_item->function);
 554 }
 555
 556 int media_playlist_update_to_db(media_playlist_h playlist)
 557 {
 558         int ret = MEDIA_CONTENT_ERROR_NONE;
 559         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 560
 561         content_retip_if_fail(playlist);
 562         content_retvm_if(!_playlist->item_list, MEDIA_CONTENT_ERROR_NONE, "operation list length is 0");
 563
 564         g_list_foreach(_playlist->item_list, __media_playlist_foreach_request, &(_playlist->playlist_id));
 565
 566         ret = media_svc_send_query(_content_get_uid());
 567
 568         __media_playlist_item_release(_playlist);
 569
 570         return _content_error_capi(ret);
 571 }
 572
 573 static int __media_playlist_get_media_id_by_path(const char *path, char **media_id)
 574 {
 575         int ret = MEDIA_CONTENT_ERROR_NONE;
 576         char *query = NULL;
 577         sqlite3_stmt *stmt = NULL;
 578
 579         content_retip_if_fail(path);
 580         content_retip_if_fail(media_id);
 581
 582 #ifdef _USE_TVPD_MODE
 583         query = sqlite3_mprintf("SELECT media_id FROM '%q' WHERE media_path='%q'", DB_VIEW_MEDIA, path);
 584 #else
 585         query = sqlite3_mprintf("SELECT media_id FROM '%q' WHERE media_path='%q'", DB_TABLE_MEDIA, path);
 586 #endif
 587         ret = _content_get_result(query, &stmt);
 588         SQLITE3_SAFE_FREE(query);
 589         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Failed to get media_id");
 590
 591         if (sqlite3_step(stmt) == SQLITE_ROW)
 592                 *media_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 593
 594         SQLITE3_FINALIZE(stmt);
 595
 596         return ret;
 597 }
 598
 599 static void __media_playlist_foreach_item(gpointer item, gpointer user_data)
 600 {
 601         int ret = MEDIA_CONTENT_ERROR_NONE;
 602         char *path = (char *)item;
 603         media_playlist_h *playlist = (media_playlist_h *)user_data;
 604         char *media_id = NULL;
 605
 606         ret = __media_playlist_get_media_id_by_path(path, &media_id);
 607         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 608                 content_sec_error("Fail to get media_id [%s]", path);
 609                 return;
 610         }
 611
 612         ret = media_playlist_add_media(*playlist, media_id);
 613         g_free(media_id);
 614         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 615                 content_sec_error("Fail to add media [%s]", path);
 616                 return;
 617         }
 618 }
 619
 620 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
 621 {
 622         int ret = MEDIA_CONTENT_ERROR_NONE;
 623         GSList *item_list = NULL;
 624         char repl_path[MAX_PATH_LEN] = {0, };
 625
 626         content_retip_if_fail(STRING_VALID(path));
 627         content_retip_if_fail(STRING_VALID(playlist_name));
 628
 629         ret = _media_content_replace_path(path, repl_path);
 630         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 631
 632         ret = media_playlist_insert_to_db(playlist_name, playlist);
 633         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
 634
 635         ret = __media_playlist_import_item_from_file(repl_path, &item_list);
 636         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Fail to get playlist from file");
 637
 638         g_slist_foreach(item_list, __media_playlist_foreach_item, playlist);
 639
 640         ret = media_playlist_update_to_db(*playlist);
 641         g_slist_free_full(item_list, g_free);
 642
 643         return ret;
 644 }
 645
 646 int media_playlist_export_to_file(media_playlist_h playlist, const char *path)
 647 {
 648         int ret = MEDIA_CONTENT_ERROR_NONE;
 649         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 650         GList *item_list = NULL;
 651         unsigned int idx = 0;
 652         char repl_path[MAX_PATH_LEN] = {0, };
 653
 654         content_retip_if_fail(STRING_VALID(path));
 655         content_retip_if_fail(playlist);
 656         content_retipm_if_fail(_playlist->playlist_id > 0, "%d", _playlist->playlist_id);
 657
 658         ret = _media_content_replace_path(path, repl_path);
 659         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 660
 661         ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
 662         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
 663
 664         ret = __media_playlist_reset_file(repl_path);
 665         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 666                 g_list_free_full(item_list, g_free);
 667                 content_error("Fail to init playlist file");
 668                 return ret;
 669         }
 670
 671         for (idx = 0; idx < g_list_length(item_list); idx++) {
 672                 char *item = g_list_nth_data(item_list, idx);
 673                 if (STRING_VALID(item)) {
 674                         ret = __media_playlist_append_to_file(repl_path, item);
 675                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 676                                 g_list_free_full(item_list, g_free);
 677                                 content_error("Fail to export paths into file");
 678                                 return ret;
 679                         }
 680                 }
 681         }
 682
 683         g_list_free_full(item_list, g_free);
 684
 685         return ret;
 686 }
 687
 688 int media_playlist_create(media_playlist_h *playlist)
 689 {
 690         content_retip_if_fail(playlist);
 691
 692         media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
 693
 694         _playlist->playlist_id = -1;
 695         _playlist->name = NULL;
 696         _playlist->thumbnail_path = NULL;
 697         _playlist->item_list = NULL;
 698
 699         *playlist = (media_playlist_h)_playlist;
 700
 701         return MEDIA_CONTENT_ERROR_NONE;
 702 }
 703
 704 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
 705 {
 706         int ret = MEDIA_CONTENT_ERROR_NONE;
 707         sqlite3_stmt *stmt = NULL;
 708         char *query = NULL;
 709
 710         content_retipm_if_fail(playlist_id >= 0, "%d", playlist_id);
 711         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 712         content_retip_if_fail(play_order);
 713
 714         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 715
 716         ret = _content_get_result(query, &stmt);
 717         SQLITE3_SAFE_FREE(query);
 718         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 719
 720         if (sqlite3_step(stmt) == SQLITE_ROW)
 721                 *play_order = sqlite3_column_int(stmt, 0);
 722
 723         SQLITE3_FINALIZE(stmt);
 724
 725         return ret;
 726 }
 727
 728 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
 729 {
 730         int ret = MEDIA_CONTENT_ERROR_NONE;
 731         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 732         int playlist_id = 0;
 733
 734         content_retip_if_fail(playlist);
 735         content_retipm_if_fail(_playlist->playlist_id == -1, "%d", _playlist->playlist_id);
 736
 737         ret = __media_playlist_insert_playlist_record(_playlist->name, &playlist_id);
 738         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 739                 __media_playlist_item_release(_playlist);
 740                 content_error("Insert playlist Fail");
 741                 return ret;
 742         }
 743
 744         _playlist->playlist_id = playlist_id;
 745
 746         return media_playlist_update_to_db(playlist);
 747 }
 748
 749 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
 750 {
 751         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 752         content_retip_if_fail(playlist);
 753
 754         _playlist->playlist_id = playlist_id;
 755
 756         return media_playlist_update_to_db(playlist);
 757 }