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