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         SAFE_FREE(_item->media_id);
  27         SAFE_FREE(_item->playlist_name);
  28         SAFE_FREE(_item->thumbnail_path);
  29         SAFE_FREE(_item);
  30 }
  31
  32 static void __media_playlist_item_release(media_playlist_s *playlist)
  33 {
  34         if (!playlist || !playlist->item_list)
  35                 return;
  36
  37         g_list_free_full(playlist->item_list, __media_playlist_item_free);
  38         playlist->item_list = NULL;
  39 }
  40
  41 static int __media_playlist_insert_playlist_record(const char *playlist_name, int *playlist_id)
  42 {
  43         int ret = MEDIA_CONTENT_ERROR_NONE;
  44         char *query = NULL;
  45         sqlite3_stmt *stmt = NULL;
  46
  47         query = sqlite3_mprintf(INSERT_PLAYLIST_TO_PLAYLIST, playlist_name);
  48
  49         ret = _content_query_sql(query);
  50         SQLITE3_SAFE_FREE(query);
  51         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  52
  53         query = sqlite3_mprintf(SELECT_PLAYLIST_ID_FROM_PLAYLIST, playlist_name);
  54
  55         ret = _content_get_result(query, &stmt);
  56         SQLITE3_SAFE_FREE(query);
  57         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  58
  59         if (sqlite3_step(stmt) == SQLITE_ROW)
  60                 *playlist_id = sqlite3_column_int(stmt, 0);
  61
  62         SQLITE3_FINALIZE(stmt);
  63
  64         return MEDIA_CONTENT_ERROR_NONE;
  65 }
  66
  67 static int __media_playlist_insert_item_to_playlist(int playlist_id, const char *media_id)
  68 {
  69         int ret = MEDIA_CONTENT_ERROR_NONE;
  70         sqlite3_stmt *stmt = NULL;
  71         char *query = NULL;
  72         int play_order = 0;
  73
  74         query = sqlite3_mprintf(SELECT_MAX_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id);
  75
  76         /* get the max play_order */
  77         ret = _content_get_result(query, &stmt);
  78         SQLITE3_SAFE_FREE(query);
  79         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  80
  81         if (sqlite3_step(stmt) == SQLITE_ROW)
  82                 play_order = sqlite3_column_int(stmt, 0);
  83
  84         SQLITE3_FINALIZE(stmt);
  85
  86         query = sqlite3_mprintf(INSERT_PLAYLIST_ITEM_TO_PLAYLIST_MAP, playlist_id, media_id, ++play_order);
  87         ret = media_svc_append_query(query, _content_get_uid());
  88
  89         return _content_error_capi(ret);
  90 }
  91
  92 static int __media_playlist_remove_item_from_playlist(int playlist_id, int playlist_member_id)
  93 {
  94         int ret = MEDIA_CONTENT_ERROR_NONE;
  95         char *query_str = NULL;
  96
  97         query_str = sqlite3_mprintf(REMOVE_PLAYLIST_ITEM_FROM_PLAYLIST_MAP, playlist_id, playlist_member_id);
  98         ret = media_svc_append_query(query_str, _content_get_uid());
  99
 100         return _content_error_capi(ret);
 101 }
 102
 103 static int __media_playlist_update_playlist_name(int playlist_id, const char *playlist_name)
 104 {
 105         int ret = MEDIA_CONTENT_ERROR_NONE;
 106         char *query_str = NULL;
 107
 108         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_NAME_FROM_PLAYLIST, playlist_name, playlist_id);
 109         ret = media_svc_append_query(query_str, _content_get_uid());
 110
 111         return _content_error_capi(ret);
 112 }
 113
 114 static int __media_playlist_update_thumbnail_path(int playlist_id, const char *path)
 115 {
 116         int ret = MEDIA_CONTENT_ERROR_NONE;
 117         char *query_str = NULL;
 118
 119         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_THUMBNAIL_FROM_PLAYLIST, path, playlist_id);
 120         ret = media_svc_append_query(query_str, _content_get_uid());
 121
 122         return _content_error_capi(ret);
 123 }
 124
 125 static int __media_playlist_update_play_order(int playlist_id, int playlist_member_id, int play_order)
 126 {
 127         int ret = MEDIA_CONTENT_ERROR_NONE;
 128         char *query_str = NULL;
 129
 130         query_str = sqlite3_mprintf(UPDATE_PLAYLIST_ORDER_FROM_PLAYLIST_MAP, play_order, playlist_id, playlist_member_id);
 131         ret = media_svc_append_query(query_str, _content_get_uid());
 132
 133         return _content_error_capi(ret);
 134 }
 135
 136 static bool __media_playlist_member_cb(int playlist_member_id, media_info_h media, void *user_data)
 137 {
 138         int ret = MEDIA_CONTENT_ERROR_NONE;
 139         GList **list = (GList**)user_data;
 140         char *path = NULL;
 141
 142         ret = media_info_get_file_path(media, &path);
 143         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, FALSE, "media_info_get_file_path fail");
 144
 145         *list = g_list_append(*list, path);
 146
 147         return TRUE;
 148 }
 149
 150 static int __media_playlist_reset_file(const char *playlist_path)
 151 {
 152         FILE *fp = NULL;
 153
 154         fp = fopen(playlist_path, "wb");
 155         if (fp == NULL) {
 156                 content_stderror("fopen failed");
 157                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 158         }
 159
 160         fputs("", fp);  /* remove previous playlist */
 161
 162         fclose(fp);
 163
 164         return MEDIA_CONTENT_ERROR_NONE;
 165 }
 166
 167 static int __media_playlist_append_to_file(const char *playlist_path, const char *path)
 168 {
 169         FILE *fp = NULL;
 170
 171         fp = fopen(playlist_path, "a"); /* append only */
 172         if (fp == NULL) {
 173                 content_stderror("fopen failed");
 174                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 175         }
 176
 177
 178         fputs(path, fp);
 179         fputs("\n", fp);
 180
 181         fclose(fp);
 182
 183         return MEDIA_CONTENT_ERROR_NONE;
 184 }
 185
 186 static int __media_playlist_import_item_from_file(const char *playlist_path, GSList **item_list)
 187 {
 188         int tmp_str_len = 0;
 189         char tmp_str[MAX_PATH_LEN] = {0, };
 190         char repl_item[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         memset(tmp_str, 0, sizeof(tmp_str));
 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
 231         media_playlist_s *_playlist = (media_playlist_s *)calloc(1, sizeof(media_playlist_s));
 232         content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 233
 234         ret = __media_playlist_insert_playlist_record(name, &playlist_id);
 235         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 236                 SAFE_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         content_retip_if_fail(playlist);
 297
 298         SAFE_FREE(_playlist->name);
 299         SAFE_FREE(_playlist->thumbnail_path);
 300         SAFE_FREE(_playlist);
 301
 302         return MEDIA_CONTENT_ERROR_NONE;
 303 }
 304
 305 int media_playlist_clone(media_playlist_h *dst, media_playlist_h src)
 306 {
 307         media_playlist_s *_src = (media_playlist_s *)src;
 308         content_retip_if_fail(_src);
 309
 310         media_playlist_s *_dst = (media_playlist_s *)calloc(1, sizeof(media_playlist_s));
 311         content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 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
 329         query = sqlite3_mprintf(SELECT_PLAYLIST_FROM_PLAYLIST, playlist_id);
 330
 331         ret = _content_get_result(query, &stmt);
 332         SQLITE3_SAFE_FREE(query);
 333         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 334
 335         media_playlist_s *_playlist = NULL;
 336
 337         if (sqlite3_step(stmt) == SQLITE_ROW) {
 338                 _playlist = (media_playlist_s *)calloc(1, sizeof(media_playlist_s));
 339                 if (_playlist == NULL) {
 340                         content_error("Out of memory");
 341                         SQLITE3_FINALIZE(stmt);
 342                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 343                 }
 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         content_retip_if_fail(playlist);
 364         content_retip_if_fail(playlist_id);
 365
 366         *playlist_id = _playlist->playlist_id;
 367
 368         return MEDIA_CONTENT_ERROR_NONE;
 369 }
 370
 371 int media_playlist_get_name(media_playlist_h playlist, char **name)
 372 {
 373         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 374         content_retip_if_fail(playlist);
 375         content_retip_if_fail(name);
 376
 377         *name = g_strdup(_playlist->name);
 378
 379         return MEDIA_CONTENT_ERROR_NONE;
 380 }
 381
 382 int media_playlist_get_thumbnail_path(media_playlist_h playlist, char **path)
 383 {
 384         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 385         content_retip_if_fail(playlist);
 386         content_retip_if_fail(path);
 387
 388         *path = g_strdup(_playlist->thumbnail_path);
 389
 390         return MEDIA_CONTENT_ERROR_NONE;
 391 }
 392
 393 int media_playlist_get_play_order(media_playlist_h playlist, int playlist_member_id, int *play_order)
 394 {
 395         int ret = MEDIA_CONTENT_ERROR_NONE;
 396         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 397         sqlite3_stmt *stmt = NULL;
 398         char *query = NULL;
 399
 400         content_retip_if_fail(playlist);
 401         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 402         content_retip_if_fail(play_order);
 403
 404         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, _playlist->playlist_id, playlist_member_id);
 405         ret = _content_get_result(query, &stmt);
 406         SQLITE3_SAFE_FREE(query);
 407         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 408
 409         if (sqlite3_step(stmt) == SQLITE_ROW)
 410                 *play_order = sqlite3_column_int(stmt, 0);
 411
 412         SQLITE3_FINALIZE(stmt);
 413
 414         return ret;
 415 }
 416
 417 int media_playlist_set_name(media_playlist_h playlist, const char *playlist_name)
 418 {
 419         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 420         media_playlist_item_s *item = NULL;
 421
 422         content_retip_if_fail(playlist);
 423         content_retip_if_fail(STRING_VALID(playlist_name));
 424
 425         SAFE_FREE(_playlist->name);
 426
 427         item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 428         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 429
 430         item->playlist_name = g_strdup(playlist_name);
 431         item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 432
 433         _playlist->name = g_strdup(playlist_name);
 434         _playlist->item_list = g_list_append(_playlist->item_list, item);
 435
 436         return MEDIA_CONTENT_ERROR_NONE;
 437 }
 438
 439 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 440 {
 441         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 442         media_playlist_item_s *item = NULL;
 443
 444         content_retip_if_fail(playlist);
 445         content_retip_if_fail(STRING_VALID(path));
 446
 447         SAFE_FREE(_playlist->thumbnail_path);
 448
 449         item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 450         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 451
 452         item->thumbnail_path = g_strdup(path);
 453         item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 454
 455         _playlist->thumbnail_path = g_strdup(path);
 456         _playlist->item_list = g_list_append(_playlist->item_list, item);
 457
 458         return MEDIA_CONTENT_ERROR_NONE;
 459 }
 460
 461 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 462 {
 463         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 464         media_playlist_item_s *item = NULL;
 465
 466         content_retip_if_fail(playlist);
 467         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 468         content_retipm_if_fail(play_order >= 0, "%d", play_order);
 469
 470         item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 471         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 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 = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 491         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 492
 493         item->media_id = g_strdup(media_id);
 494         item->function = MEDIA_PLAYLIST_ADD;
 495
 496         _playlist->item_list = g_list_append(_playlist->item_list, item);
 497
 498         return MEDIA_CONTENT_ERROR_NONE;
 499 }
 500
 501 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 502 {
 503         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 504         media_playlist_item_s *item = NULL;
 505
 506         content_retip_if_fail(playlist);
 507         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 508
 509         item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 510         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 511
 512         item->playlist_member_id = playlist_member_id;
 513         item->function = MEDIA_PLAYLIST_REMOVE;
 514
 515         _playlist->item_list = g_list_append(_playlist->item_list, item);
 516
 517         return MEDIA_CONTENT_ERROR_NONE;
 518 }
 519
 520 void __media_playlist_foreach_request(gpointer data, gpointer user_data)
 521 {
 522         int ret = MEDIA_CONTENT_ERROR_NONE;
 523         media_playlist_item_s *_playlist_item = (media_playlist_item_s *)data;
 524         int playlist_id = *((int *)user_data);
 525
 526         if (!_playlist_item)
 527                 return;
 528
 529         switch (_playlist_item->function) {
 530         case MEDIA_PLAYLIST_ADD:
 531                 ret = __media_playlist_insert_item_to_playlist(playlist_id, _playlist_item->media_id);
 532                 break;
 533
 534         case MEDIA_PLAYLIST_REMOVE:
 535                 ret = __media_playlist_remove_item_from_playlist(playlist_id, _playlist_item->playlist_member_id);
 536                 break;
 537
 538         case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 539                 ret = __media_playlist_update_playlist_name(playlist_id, _playlist_item->playlist_name);
 540                 break;
 541
 542         case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 543                 ret = __media_playlist_update_thumbnail_path(playlist_id, _playlist_item->thumbnail_path);
 544                 break;
 545
 546         case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 547                 ret = __media_playlist_update_play_order(playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 548                 break;
 549
 550         default:
 551                 break;
 552         }
 553
 554         if (ret != MEDIA_CONTENT_ERROR_NONE)
 555                 content_error("Failed some operation[%d]", _playlist_item->function);
 556 }
 557
 558 int media_playlist_update_to_db(media_playlist_h playlist)
 559 {
 560         int ret = MEDIA_CONTENT_ERROR_NONE;
 561         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 562
 563         content_retip_if_fail(playlist);
 564         content_retvm_if(!_playlist->item_list, MEDIA_CONTENT_ERROR_NONE, "operation list length is 0");
 565
 566         g_list_foreach(_playlist->item_list, __media_playlist_foreach_request, &(_playlist->playlist_id));
 567
 568         ret = media_svc_send_query(_content_get_uid());
 569
 570         __media_playlist_item_release(_playlist);
 571
 572         return _content_error_capi(ret);
 573 }
 574
 575 static int __media_playlist_get_media_id_by_path(const char *path, char **media_id)
 576 {
 577         int ret = MEDIA_CONTENT_ERROR_NONE;
 578         char *query = NULL;
 579         sqlite3_stmt *stmt = NULL;
 580         content_retip_if_fail(path);
 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         memset(repl_path, 0, sizeof(repl_path));
 630         ret = _media_content_replace_path(path, repl_path);
 631         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 632
 633         ret = media_playlist_insert_to_db(playlist_name, playlist);
 634         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
 635
 636         ret = __media_playlist_import_item_from_file(repl_path, &item_list);
 637         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Fail to get playlist from file");
 638
 639         g_slist_foreach(item_list, __media_playlist_foreach_item, playlist);
 640
 641         ret = media_playlist_update_to_db(*playlist);
 642         g_slist_free_full(item_list, g_free);
 643
 644         return ret;
 645 }
 646
 647 int media_playlist_export_to_file(media_playlist_h playlist, const char *path)
 648 {
 649         int ret = MEDIA_CONTENT_ERROR_NONE;
 650         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 651         GList *item_list = NULL;
 652         unsigned int idx = 0;
 653         char repl_path[MAX_PATH_LEN] = {0, };
 654
 655         content_retip_if_fail(STRING_VALID(path));
 656         content_retip_if_fail(playlist);
 657         content_retipm_if_fail(_playlist->playlist_id > 0, "%d", _playlist->playlist_id);
 658
 659         memset(repl_path, 0, sizeof(repl_path));
 660         ret = _media_content_replace_path(path, repl_path);
 661         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 662
 663         ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
 664         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
 665
 666         ret = __media_playlist_reset_file(repl_path);
 667         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 668                 g_list_free_full(item_list, g_free);
 669                 content_error("Fail to init playlist file");
 670                 return ret;
 671         }
 672
 673         for (idx = 0; idx < g_list_length(item_list); idx++) {
 674                 char *item = g_list_nth_data(item_list, idx);
 675                 if (STRING_VALID(item)) {
 676                         ret = __media_playlist_append_to_file(repl_path, item);
 677                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 678                                 g_list_free_full(item_list, g_free);
 679                                 content_error("Fail to export paths into file");
 680                                 return ret;
 681                         }
 682                 }
 683         }
 684
 685         g_list_free_full(item_list, g_free);
 686
 687         return ret;
 688 }
 689
 690 int media_playlist_create(media_playlist_h *playlist)
 691 {
 692         content_retip_if_fail(playlist);
 693
 694         media_playlist_s *_playlist = (media_playlist_s *)calloc(1, sizeof(media_playlist_s));
 695         content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 696
 697         _playlist->playlist_id = -1;
 698         _playlist->name = NULL;
 699         _playlist->thumbnail_path = NULL;
 700         _playlist->item_list = NULL;
 701
 702         *playlist = (media_playlist_h)_playlist;
 703
 704         return MEDIA_CONTENT_ERROR_NONE;
 705 }
 706
 707 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
 708 {
 709         int ret = MEDIA_CONTENT_ERROR_NONE;
 710         sqlite3_stmt *stmt = NULL;
 711         char *query = NULL;
 712
 713         content_retipm_if_fail(playlist_id >= 0, "%d", playlist_id);
 714         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 715         content_retip_if_fail(play_order);
 716
 717         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 718
 719         ret = _content_get_result(query, &stmt);
 720         SQLITE3_SAFE_FREE(query);
 721         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 722
 723         if (sqlite3_step(stmt) == SQLITE_ROW)
 724                 *play_order = sqlite3_column_int(stmt, 0);
 725
 726         SQLITE3_FINALIZE(stmt);
 727
 728         return ret;
 729 }
 730
 731 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
 732 {
 733         int ret = MEDIA_CONTENT_ERROR_NONE;
 734         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 735         int playlist_id = 0;
 736
 737         content_retip_if_fail(playlist);
 738         content_retipm_if_fail(_playlist->playlist_id == -1, "%d", _playlist->playlist_id);
 739
 740         ret = __media_playlist_insert_playlist_record(_playlist->name, &playlist_id);
 741         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 742                 __media_playlist_item_release(_playlist);
 743                 content_error("Insert playlist Fail");
 744                 return ret;
 745         }
 746
 747         _playlist->playlist_id = playlist_id;
 748
 749         return media_playlist_update_to_db(playlist);
 750 }
 751
 752 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
 753 {
 754         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 755         content_retip_if_fail(playlist);
 756
 757         _playlist->playlist_id = playlist_id;
 758
 759         return media_playlist_update_to_db(playlist);
 760 }