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
 421         content_retip_if_fail(playlist);
 422         content_retip_if_fail(STRING_VALID(playlist_name));
 423
 424         SAFE_FREE(_playlist->name);
 425
 426         media_playlist_item_s *item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 427         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 428
 429         item->playlist_name = g_strdup(playlist_name);
 430         item->function = MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME;
 431
 432         _playlist->name = g_strdup(playlist_name);
 433         _playlist->item_list = g_list_append(_playlist->item_list, item);
 434
 435         return MEDIA_CONTENT_ERROR_NONE;
 436 }
 437
 438 int media_playlist_set_thumbnail_path(media_playlist_h playlist, const char *path)
 439 {
 440         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 441
 442         content_retip_if_fail(playlist);
 443         content_retip_if_fail(STRING_VALID(path));
 444
 445         SAFE_FREE(_playlist->thumbnail_path);
 446
 447         media_playlist_item_s *item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 448         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 449
 450         item->thumbnail_path = g_strdup(path);
 451         item->function = MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH;
 452
 453         _playlist->thumbnail_path = g_strdup(path);
 454         _playlist->item_list = g_list_append(_playlist->item_list, item);
 455
 456         return MEDIA_CONTENT_ERROR_NONE;
 457 }
 458
 459 int media_playlist_set_play_order(media_playlist_h playlist, int playlist_member_id, int play_order)
 460 {
 461         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 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         media_playlist_item_s *item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 468         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 469
 470         item->playlist_member_id = playlist_member_id;
 471         item->function = MEDIA_PLAYLIST_UPDATE_PLAY_ORDER;
 472         item->play_order = play_order;
 473
 474         _playlist->item_list = g_list_append(_playlist->item_list, item);
 475
 476         return MEDIA_CONTENT_ERROR_NONE;
 477 }
 478
 479 int media_playlist_add_media(media_playlist_h playlist, const char *media_id)
 480 {
 481         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 482
 483         content_retip_if_fail(playlist);
 484         content_retip_if_fail(STRING_VALID(media_id));
 485
 486         media_playlist_item_s *item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 487         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 488
 489         item->media_id = g_strdup(media_id);
 490         item->function = MEDIA_PLAYLIST_ADD;
 491
 492         _playlist->item_list = g_list_append(_playlist->item_list, item);
 493
 494         return MEDIA_CONTENT_ERROR_NONE;
 495 }
 496
 497 int media_playlist_remove_media(media_playlist_h playlist, int playlist_member_id)
 498 {
 499         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 500
 501         content_retip_if_fail(playlist);
 502         content_retipm_if_fail(playlist_member_id > 0, "%d", playlist_member_id);
 503
 504         media_playlist_item_s *item = (media_playlist_item_s *)calloc(1, sizeof(media_playlist_item_s));
 505         content_retvm_if(item == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 506
 507         item->playlist_member_id = playlist_member_id;
 508         item->function = MEDIA_PLAYLIST_REMOVE;
 509
 510         _playlist->item_list = g_list_append(_playlist->item_list, item);
 511
 512         return MEDIA_CONTENT_ERROR_NONE;
 513 }
 514
 515 void __media_playlist_foreach_request(gpointer data, gpointer user_data)
 516 {
 517         int ret = MEDIA_CONTENT_ERROR_NONE;
 518         media_playlist_item_s *_playlist_item = (media_playlist_item_s *)data;
 519         int playlist_id = *((int *)user_data);
 520
 521         if (!_playlist_item)
 522                 return;
 523
 524         switch (_playlist_item->function) {
 525         case MEDIA_PLAYLIST_ADD:
 526                 ret = __media_playlist_insert_item_to_playlist(playlist_id, _playlist_item->media_id);
 527                 break;
 528
 529         case MEDIA_PLAYLIST_REMOVE:
 530                 ret = __media_playlist_remove_item_from_playlist(playlist_id, _playlist_item->playlist_member_id);
 531                 break;
 532
 533         case MEDIA_PLAYLIST_UPDATE_PLAYLIST_NAME:
 534                 ret = __media_playlist_update_playlist_name(playlist_id, _playlist_item->playlist_name);
 535                 break;
 536
 537         case MEDIA_PLAYLIST_UPDATE_THUMBNAIL_PATH:
 538                 ret = __media_playlist_update_thumbnail_path(playlist_id, _playlist_item->thumbnail_path);
 539                 break;
 540
 541         case MEDIA_PLAYLIST_UPDATE_PLAY_ORDER:
 542                 ret = __media_playlist_update_play_order(playlist_id, _playlist_item->playlist_member_id, _playlist_item->play_order);
 543                 break;
 544
 545         default:
 546                 break;
 547         }
 548
 549         if (ret != MEDIA_CONTENT_ERROR_NONE)
 550                 content_error("Failed some operation[%d]", _playlist_item->function);
 551 }
 552
 553 int media_playlist_update_to_db(media_playlist_h playlist)
 554 {
 555         int ret = MEDIA_CONTENT_ERROR_NONE;
 556         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 557
 558         content_retip_if_fail(playlist);
 559         content_retvm_if(!_playlist->item_list, MEDIA_CONTENT_ERROR_NONE, "operation list length is 0");
 560
 561         g_list_foreach(_playlist->item_list, __media_playlist_foreach_request, &(_playlist->playlist_id));
 562
 563         ret = media_svc_send_query(_content_get_uid());
 564
 565         __media_playlist_item_release(_playlist);
 566
 567         return _content_error_capi(ret);
 568 }
 569
 570 static int __media_playlist_get_media_id_by_path(const char *path, char **media_id)
 571 {
 572         int ret = MEDIA_CONTENT_ERROR_NONE;
 573         char *query = NULL;
 574         sqlite3_stmt *stmt = NULL;
 575         content_retip_if_fail(path);
 576
 577 #ifdef _USE_TVPD_MODE
 578         query = sqlite3_mprintf("SELECT media_id FROM '%q' WHERE media_path='%q'", DB_VIEW_MEDIA, path);
 579 #else
 580         query = sqlite3_mprintf("SELECT media_id FROM '%q' WHERE media_path='%q'", DB_TABLE_MEDIA, path);
 581 #endif
 582         ret = _content_get_result(query, &stmt);
 583         SQLITE3_SAFE_FREE(query);
 584         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Failed to get media_id");
 585
 586         if (sqlite3_step(stmt) == SQLITE_ROW)
 587                 *media_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 588
 589         SQLITE3_FINALIZE(stmt);
 590
 591         return ret;
 592 }
 593
 594 static void __media_playlist_foreach_item(gpointer item, gpointer user_data)
 595 {
 596         int ret = MEDIA_CONTENT_ERROR_NONE;
 597         char *path = (char *)item;
 598         media_playlist_h *playlist = (media_playlist_h *)user_data;
 599         char *media_id = NULL;
 600
 601         ret = __media_playlist_get_media_id_by_path(path, &media_id);
 602         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 603                 content_sec_error("Fail to get media_id [%s]", path);
 604                 return;
 605         }
 606
 607         ret = media_playlist_add_media(*playlist, media_id);
 608         g_free(media_id);
 609         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 610                 content_sec_error("Fail to add media [%s]", path);
 611                 return;
 612         }
 613 }
 614
 615 int media_playlist_import_from_file(const char *path, const char *playlist_name, media_playlist_h *playlist)
 616 {
 617         int ret = MEDIA_CONTENT_ERROR_NONE;
 618         GSList *item_list = NULL;
 619         char repl_path[MAX_PATH_LEN] = {0, };
 620
 621         content_retip_if_fail(STRING_VALID(path));
 622         content_retip_if_fail(STRING_VALID(playlist_name));
 623
 624         memset(repl_path, 0, sizeof(repl_path));
 625         ret = _media_content_replace_path(path, repl_path);
 626         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 627
 628         ret = media_playlist_insert_to_db(playlist_name, playlist);
 629         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_playlist_insert_to_db fail");
 630
 631         ret = __media_playlist_import_item_from_file(repl_path, &item_list);
 632         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Fail to get playlist from file");
 633
 634         g_slist_foreach(item_list, __media_playlist_foreach_item, playlist);
 635
 636         ret = media_playlist_update_to_db(*playlist);
 637         g_slist_free_full(item_list, g_free);
 638
 639         return ret;
 640 }
 641
 642 int media_playlist_export_to_file(media_playlist_h playlist, const char *path)
 643 {
 644         int ret = MEDIA_CONTENT_ERROR_NONE;
 645         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 646         GList *item_list = NULL;
 647         unsigned int idx = 0;
 648         char repl_path[MAX_PATH_LEN] = {0, };
 649
 650         content_retip_if_fail(STRING_VALID(path));
 651         content_retip_if_fail(playlist);
 652         content_retipm_if_fail(_playlist->playlist_id > 0, "%d", _playlist->playlist_id);
 653
 654         memset(repl_path, 0, sizeof(repl_path));
 655         ret = _media_content_replace_path(path, repl_path);
 656         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 657
 658         ret = _media_db_get_playlist_item(_playlist->playlist_id, NULL, __media_playlist_member_cb, &item_list);
 659         content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "_media_db_get_playlist_item fail");
 660
 661         ret = __media_playlist_reset_file(repl_path);
 662         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 663                 g_list_free_full(item_list, g_free);
 664                 content_error("Fail to init playlist file");
 665                 return ret;
 666         }
 667
 668         for (idx = 0; idx < g_list_length(item_list); idx++) {
 669                 char *item = g_list_nth_data(item_list, idx);
 670                 if (STRING_VALID(item)) {
 671                         ret = __media_playlist_append_to_file(repl_path, item);
 672                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 673                                 g_list_free_full(item_list, g_free);
 674                                 content_error("Fail to export paths into file");
 675                                 return ret;
 676                         }
 677                 }
 678         }
 679
 680         g_list_free_full(item_list, g_free);
 681
 682         return ret;
 683 }
 684
 685 int media_playlist_create(media_playlist_h *playlist)
 686 {
 687         content_retip_if_fail(playlist);
 688
 689         media_playlist_s *_playlist = (media_playlist_s *)calloc(1, sizeof(media_playlist_s));
 690         content_retvm_if(_playlist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 691
 692         _playlist->playlist_id = -1;
 693         _playlist->name = NULL;
 694         _playlist->thumbnail_path = NULL;
 695         _playlist->item_list = NULL;
 696
 697         *playlist = (media_playlist_h)_playlist;
 698
 699         return MEDIA_CONTENT_ERROR_NONE;
 700 }
 701
 702 int media_playlist_get_play_order_v2(int playlist_id, int playlist_member_id, int *play_order)
 703 {
 704         int ret = MEDIA_CONTENT_ERROR_NONE;
 705         sqlite3_stmt *stmt = NULL;
 706         char *query = NULL;
 707
 708         content_retipm_if_fail(playlist_id >= 0, "%d", playlist_id);
 709         content_retipm_if_fail(playlist_member_id >= 0, "%d", playlist_member_id);
 710         content_retip_if_fail(play_order);
 711
 712         query = sqlite3_mprintf(SELECT_PLAY_ORDER_FROM_PLAYLIST_VIEW, playlist_id, playlist_member_id);
 713
 714         ret = _content_get_result(query, &stmt);
 715         SQLITE3_SAFE_FREE(query);
 716         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 717
 718         if (sqlite3_step(stmt) == SQLITE_ROW)
 719                 *play_order = sqlite3_column_int(stmt, 0);
 720
 721         SQLITE3_FINALIZE(stmt);
 722
 723         return ret;
 724 }
 725
 726 int media_playlist_insert_to_db_v2(media_playlist_h playlist)
 727 {
 728         int ret = MEDIA_CONTENT_ERROR_NONE;
 729         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 730         int playlist_id = 0;
 731
 732         content_retip_if_fail(playlist);
 733         content_retipm_if_fail(_playlist->playlist_id == -1, "%d", _playlist->playlist_id);
 734
 735         ret = __media_playlist_insert_playlist_record(_playlist->name, &playlist_id);
 736         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 737                 __media_playlist_item_release(_playlist);
 738                 content_error("Insert playlist Fail");
 739                 return ret;
 740         }
 741
 742         _playlist->playlist_id = playlist_id;
 743
 744         return media_playlist_update_to_db(playlist);
 745 }
 746
 747 int media_playlist_update_to_db_v2(int playlist_id, media_playlist_h playlist)
 748 {
 749         media_playlist_s *_playlist = (media_playlist_s *)playlist;
 750         content_retip_if_fail(playlist);
 751
 752         _playlist->playlist_id = playlist_id;
 753
 754         return media_playlist_update_to_db(playlist);
 755 }