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         FILE *fp = NULL;
 192
 193         fp = fopen(playlist_path, "rb");
 194         if (fp == NULL) {
 195                 content_stderror("fopen failed");
 196                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 197         }
 198
 199         while (fgets(tmp_str, MAX_PATH_LEN, fp) != NULL) {
 200                 tmp_str_len = strlen(tmp_str);
 201                 /* Check for empty file */
 202                 if (tmp_str_len <= 1)
 203                         continue;
 204
 205                 if (tmp_str[0] == '#')
 206                         continue;
 207
 208
 209                 if (tmp_str[tmp_str_len - 1] == '\n')
 210                         tmp_str[tmp_str_len - 1] = '\0';
 211
 212                 *item_list = g_slist_append(*item_list, g_strdup(tmp_str));
 213         }
 214
 215         fclose(fp);
 216
 217         return MEDIA_CONTENT_ERROR_NONE;
 218 }
 219
 220 int media_playlist_insert_to_db(const char *name, media_playlist_h *playlist)
 221 {
 222         int ret = MEDIA_CONTENT_ERROR_NONE;
 223         int playlist_id = 0;
 224
 225         content_retip_if_fail(STRING_VALID(name));
 226         content_retip_if_fail(playlist);
 227
 228         media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
 229
 230         ret = __media_playlist_insert_playlist_record(name, &playlist_id);
 231         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 232                 g_free(_playlist);
 233                 return ret;
 234         }
 235
 236         _playlist->playlist_id = playlist_id;
 237         _playlist->name = g_strdup(name);
 238
 239         *playlist = (media_playlist_h)_playlist;
 240
 241         return ret;
 242 }
 243
 244 int media_playlist_delete_from_db(int playlist_id)
 245 {
 246         int ret = MEDIA_CONTENT_ERROR_NONE;
 247         char *query_str = NULL;
 248
 249         content_retipm_if_fail(playlist_id >= 0, "%d", playlist_id);
 250
 251         query_str = sqlite3_mprintf(DELETE_PLAYLIST_FROM_PLAYLIST, playlist_id);
 252
 253         ret = _content_query_sql(query_str);
 254         SQLITE3_SAFE_FREE(query_str);
 255
 256         return ret;
 257 }
 258
 259 int media_playlist_get_playlist_count_from_db(filter_h filter, int *playlist_count)
 260 {
 261         content_retip_if_fail(playlist_count);
 262
 263         return _media_db_get_group_count(filter, MEDIA_GROUP_PLAYLIST, playlist_count);
 264 }
 265
 266 int media_playlist_foreach_playlist_from_db(filter_h filter, media_playlist_cb callback, void *user_data)
 267 {
 268         content_retip_if_fail(callback);
 269
 270         return _media_db_get_playlist(filter, callback, user_data);
 271 }
 272
 273 int media_playlist_get_media_count_from_db(int playlist_id, filter_h filter, int *media_count)
 274 {
 275         content_retip_if_fail(media_count);
 276         content_retipm_if_fail(playlist_id > 0, "%d", playlist_id);
 277
 278         return _media_db_get_group_item_count_by_id(playlist_id, filter, MEDIA_GROUP_PLAYLIST, media_count);
 279 }
 280
 281 int media_playlist_foreach_media_from_db(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 282 {
 283         content_retip_if_fail(callback);
 284         content_retipm_if_fail(playlist_id > 0, "%d", playlist_id);
 285
 286         return _media_db_get_playlist_item(playlist_id, filter, callback, user_data);
 287 }
 288
 289 int media_playlist_destroy(media_playlist_h playlist)
 290 {
 291         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 292
 293         content_retip_if_fail(playlist);
 294
 295         __media_playlist_item_release(_playlist);
 296
 297         g_free(_playlist->name);
 298         g_free(_playlist->thumbnail_path);
 299         g_free(_playlist);
 300
 301         return MEDIA_CONTENT_ERROR_NONE;
 302 }
 303
 304 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
 305 {
 306         media_playlist_s *_src = (media_playlist_s *)src;
 307
 308         content_retip_if_fail(dst);
 309         content_retip_if_fail(src);
 310
 311         media_playlist_s *_dst = g_new0(media_playlist_s, 1);
 312
 313         _dst->playlist_id = _src->playlist_id;
 314         _dst->name = g_strdup(_src->name);
 315
 316         *dst = (media_playlist_h)_dst;
 317
 318         return MEDIA_CONTENT_ERROR_NONE;
 319 }
 320
 321 int media_playlist_get_playlist_from_db(int playlist_id, media_playlist_h *playlist)
 322 {
 323         int ret = MEDIA_CONTENT_ERROR_NONE;
 324         sqlite3_stmt *stmt = NULL;
 325         char *query = NULL;
 326
 327         content_retipm_if_fail(playlist_id > 0, "%d", playlist_id);
 328         content_retip_if_fail(playlist);
 329
 330         query = sqlite3_mprintf(SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
 331
 332         ret = _content_get_result(query, &stmt);
 333         SQLITE3_SAFE_FREE(query);
 334         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 335
 336         media_playlist_s *_playlist = NULL;
 337
 338         if (sqlite3_step(stmt) == SQLITE_ROW) {
 339                 _playlist = g_new0(media_playlist_s, 1);
 340
 341                 _playlist->playlist_id = playlist_id;
 342                 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 343                 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 344
 345                 *playlist = (media_playlist_h)_playlist;
 346         } else {
 347                 content_error("Nonexistent playlist id[%d]", playlist_id);
 348                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 349         }
 350
 351         SQLITE3_FINALIZE(stmt);
 352
 353         return ret;
 354 }
 355
 356 int media_playlist_get_playlist_id(media_playlist_h playlist, int *playlist_id)
 357 {
 358         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 359
 360         content_retip_if_fail(playlist);
 361         content_retip_if_fail(playlist_id);
 362
 363         *playlist_id = _playlist->playlist_id;
 364
 365         return MEDIA_CONTENT_ERROR_NONE;
 366 }
 367
 368 int media_playlist_get_name(media_playlist_h playlist, char **name)
 369 {
 370         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 371
 372         content_retip_if_fail(playlist);
 373         content_retip_if_fail(name);
 374
 375         *name = g_strdup(_playlist->name);
 376
 377         return MEDIA_CONTENT_ERROR_NONE;
 378 }
 379
 380 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
 381 {
 382         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 383
 384         content_retip_if_fail(playlist);
 385         content_retip_if_fail(path);
 386
 387         *path = g_strdup(_playlist->thumbnail_path);
 388
 389         return MEDIA_CONTENT_ERROR_NONE;
 390 }
 391
 392 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
 393 {
 394         int ret = MEDIA_CONTENT_ERROR_NONE;
 395         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 396         sqlite3_stmt *stmt = NULL;
 397         char *query = NULL;
 398
 399         content_retip_if_fail(playlist);
 400         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 401         content_retip_if_fail(play_order);
 402
 403         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, _playlist->playlist_id, playlist_member_id);
 404         ret = _content_get_result(query, &stmt);
 405         SQLITE3_SAFE_FREE(query);
 406         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 407
 408         if (sqlite3_step(stmt) == SQLITE_ROW)
 409                 *play_order = sqlite3_column_int(stmt, 0);
 410
 411         SQLITE3_FINALIZE(stmt);
 412
 413         return ret;
 414 }
 415
 416 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
 417 {
 418         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 419         media_playlist_item_s *item = NULL;
 420
 421         content_retip_if_fail(playlist);
 422         content_retip_if_fail(STRING_VALID(playlist_name));
 423
 424         g_free(_playlist->name);
 425
 426         item = g_new0(media_playlist_item_s, 1);
 427
 428         item->playlist_name = g_strdup(playlist_name);
 429         item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 430
 431         _playlist->name = g_strdup(playlist_name);
 432         _playlist->item_list = g_list_append(_playlist->item_list, item);
 433
 434         return MEDIA_CONTENT_ERROR_NONE;
 435 }
 436
 437 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 438 {
 439         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 440         media_playlist_item_s *item = NULL;
 441
 442         content_retip_if_fail(playlist);
 443         content_retip_if_fail(STRING_VALID(path));
 444
 445         g_free(_playlist->thumbnail_path);
 446
 447         item = g_new0(media_playlist_item_s, 1);
 448
 449         item->thumbnail_path = g_strdup(path);
 450         item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 451
 452         _playlist->thumbnail_path = g_strdup(path);
 453         _playlist->item_list = g_list_append(_playlist->item_list, item);
 454
 455         return MEDIA_CONTENT_ERROR_NONE;
 456 }
 457
 458 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 459 {
 460         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 461         media_playlist_item_s *item = NULL;
 462
 463         content_retip_if_fail(playlist);
 464         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 465         content_retipm_if_fail(play_order >= 0, "%d", play_order);
 466
 467         item = g_new0(media_playlist_item_s, 1);
 468
 469         item->playlist_member_id = playlist_member_id;
 470         item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
 471         item->play_order = play_order;
 472
 473         _playlist->item_list = g_list_append(_playlist->item_list, item);
 474
 475         return MEDIA_CONTENT_ERROR_NONE;
 476 }
 477
 478 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
 479 {
 480         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 481         media_playlist_item_s *item = NULL;
 482
 483         content_retip_if_fail(playlist);
 484         content_retip_if_fail(STRING_VALID(media_id));
 485
 486         item = g_new0(media_playlist_item_s, 1);
 487
 488         item->media_id = g_strdup(media_id);
 489         item->function = MEDIA_PLAYLIST_ADD;
 490
 491         _playlist->item_list = g_list_append(_playlist->item_list, item);
 492
 493         return MEDIA_CONTENT_ERROR_NONE;
 494 }
 495
 496 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 497 {
 498         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 499         media_playlist_item_s *item = NULL;
 500
 501         content_retip_if_fail(playlist);
 502         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 503
 504         item = g_new0(media_playlist_item_s, 1);
 505
 506         item->playlist_member_id = playlist_member_id;
 507         item->function = MEDIA_PLAYLIST_REMOVE;
 508
 509         _playlist->item_list = g_list_append(_playlist->item_list, item);
 510
 511         return MEDIA_CONTENT_ERROR_NONE;
 512 }
 513
 514 void __media_playlist_foreach_request(gpointer data, gpointer user_data)
 515 {
 516         int ret = MEDIA_CONTENT_ERROR_NONE;
 517         media_playlist_item_s *_playlist_item = (media_playlist_item_s *)data;
 518         int playlist_id = *((int *)user_data);
 519
 520         if (!_playlist_item)
 521                 return;
 522
 523         switch (_playlist_item->function) {
 524         case MEDIA_PLAYLIST_ADD:
 525                 ret = __media_playlist_insert_item_to_playlist(playlist_id, _playlist_item->media_id);
 526                 break;
 527
 528         case MEDIA_PLAYLIST_REMOVE:
 529                 ret = __media_playlist_remove_item_from_playlist(playlist_id, _playlist_item->playlist_member_id);
 530                 break;
 531
 532         case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 533                 ret = __media_playlist_update_playlist_name(playlist_id, _playlist_item->playlist_name);
 534                 break;
 535
 536         case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 537                 ret = __media_playlist_update_thumbnail_path(playlist_id, _playlist_item->thumbnail_path);
 538                 break;
 539
 540         case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 541                 ret = __media_playlist_update_play_order(playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 542                 break;
 543
 544         default:
 545                 break;
 546         }
 547
 548         if (ret != MEDIA_CONTENT_ERROR_NONE)
 549                 content_error("Failed some operation[%d]", _playlist_item->function);
 550 }
 551
 552 int media_playlist_update_to_db(media_playlist_h playlist)
 553 {
 554         int ret = MEDIA_CONTENT_ERROR_NONE;
 555         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 556
 557         content_retip_if_fail(playlist);
 558         content_retvm_if(!_playlist->item_list, MEDIA_CONTENT_ERROR_NONE, "operation list length is 0");
 559
 560         g_list_foreach(_playlist->item_list, __media_playlist_foreach_request, &(_playlist->playlist_id));
 561
 562         ret = media_svc_send_query(_content_get_uid());
 563
 564         __media_playlist_item_release(_playlist);
 565
 566         return _content_error_capi(ret);
 567 }
 568
 569 static int __media_playlist_get_media_id_by_path(const char *path, char **media_id)
 570 {
 571         int ret = MEDIA_CONTENT_ERROR_NONE;
 572         char *query = NULL;
 573         sqlite3_stmt *stmt = NULL;
 574
 575         content_retip_if_fail(path);
 576         content_retip_if_fail(media_id);
 577
 578 #ifdef _USE_TVPD_MODE
 579         query = sqlite3_mprintf("SELECT media_id FROM '%q' WHERE media_path='%q'", DB_VIEW_MEDIA, path);
 580 #else
 581         query = sqlite3_mprintf("SELECT media_id FROM '%q' WHERE media_path='%q'", DB_TABLE_MEDIA, path);
 582 #endif
 583         ret = _content_get_result(query, &stmt);
 584         SQLITE3_SAFE_FREE(query);
 585         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Failed to get media_id");
 586
 587         if (sqlite3_step(stmt) == SQLITE_ROW)
 588                 *media_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 589
 590         SQLITE3_FINALIZE(stmt);
 591
 592         return ret;
 593 }
 594
 595 static void __media_playlist_foreach_item(gpointer item, gpointer user_data)
 596 {
 597         int ret = MEDIA_CONTENT_ERROR_NONE;
 598         char *path = (char *)item;
 599         media_playlist_h *playlist = (media_playlist_h *)user_data;
 600         char *media_id = NULL;
 601
 602         ret = __media_playlist_get_media_id_by_path(path, &media_id);
 603         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 604                 content_sec_error("Fail to get media_id [%s]", path);
 605                 return;
 606         }
 607
 608         ret = media_playlist_add_media(*playlist, media_id);
 609         g_free(media_id);
 610         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 611                 content_sec_error("Fail to add media [%s]", path);
 612                 return;
 613         }
 614 }
 615
 616 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
 617 {
 618         int ret = MEDIA_CONTENT_ERROR_NONE;
 619         GSList *item_list = NULL;
 620
 621         content_retip_if_fail(STRING_VALID(path));
 622         content_retip_if_fail(STRING_VALID(playlist_name));
 623
 624         ret = media_playlist_insert_to_db(playlist_name, playlist);
 625         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
 626
 627         ret = __media_playlist_import_item_from_file(path, &item_list);
 628         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Fail to get playlist from file");
 629
 630         g_slist_foreach(item_list, __media_playlist_foreach_item, playlist);
 631
 632         ret = media_playlist_update_to_db(*playlist);
 633         g_slist_free_full(item_list, g_free);
 634
 635         return ret;
 636 }
 637
 638 int media_playlist_export_to_file(media_playlist_h playlist, const char *path)
 639 {
 640         int ret = MEDIA_CONTENT_ERROR_NONE;
 641         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 642         GList *item_list = NULL;
 643         GList *iter = NULL;
 644         char *item = NULL;
 645
 646         content_retip_if_fail(STRING_VALID(path));
 647         content_retip_if_fail(playlist);
 648         content_retipm_if_fail(_playlist->playlist_id > 0, "%d", _playlist->playlist_id);
 649
 650         ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
 651         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
 652
 653         ret = __media_playlist_reset_file(path);
 654         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 655                 content_error("Fail to init playlist file");
 656                 goto FINALIZE;
 657         }
 658
 659         for (iter = item_list; iter; iter = g_list_next(iter)) {
 660                 item = (char *)iter->data;
 661                 if (!STRING_VALID(item))
 662                         continue;
 663
 664                 ret = __media_playlist_append_to_file(path, item);
 665                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 666                         content_error("Fail to export paths into file");
 667                         goto FINALIZE;
 668                 }
 669         }
 670
 671 FINALIZE:
 672         g_list_free_full(item_list, g_free);
 673
 674         return ret;
 675 }
 676
 677 int media_playlist_create(media_playlist_h *playlist)
 678 {
 679         content_retip_if_fail(playlist);
 680
 681         media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
 682
 683         _playlist->playlist_id = -1;
 684         _playlist->name = NULL;
 685         _playlist->thumbnail_path = NULL;
 686         _playlist->item_list = NULL;
 687
 688         *playlist = (media_playlist_h)_playlist;
 689
 690         return MEDIA_CONTENT_ERROR_NONE;
 691 }
 692
 693 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
 694 {
 695         int ret = MEDIA_CONTENT_ERROR_NONE;
 696         sqlite3_stmt *stmt = NULL;
 697         char *query = NULL;
 698
 699         content_retipm_if_fail(playlist_id >= 0, "%d", playlist_id);
 700         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 701         content_retip_if_fail(play_order);
 702
 703         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 704
 705         ret = _content_get_result(query, &stmt);
 706         SQLITE3_SAFE_FREE(query);
 707         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 708
 709         if (sqlite3_step(stmt) == SQLITE_ROW)
 710                 *play_order = sqlite3_column_int(stmt, 0);
 711
 712         SQLITE3_FINALIZE(stmt);
 713
 714         return ret;
 715 }
 716
 717 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
 718 {
 719         int ret = MEDIA_CONTENT_ERROR_NONE;
 720         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 721         int playlist_id = 0;
 722
 723         content_retip_if_fail(playlist);
 724         content_retipm_if_fail(_playlist->playlist_id == -1, "%d", _playlist->playlist_id);
 725
 726         ret = __media_playlist_insert_playlist_record(_playlist->name, &playlist_id);
 727         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 728                 __media_playlist_item_release(_playlist);
 729                 content_error("Insert playlist Fail");
 730                 return ret;
 731         }
 732
 733         _playlist->playlist_id = playlist_id;
 734
 735         return media_playlist_update_to_db(playlist);
 736 }
 737
 738 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
 739 {
 740         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 741         content_retip_if_fail(playlist);
 742
 743         _playlist->playlist_id = playlist_id;
 744
 745         return media_playlist_update_to_db(playlist);
 746 }